Parameterized Construction of Program Representations for Sparse Dataflow Analyses

Data-flow analyses usually associate information with control flow regions. Informally, if these regions are too small, like a point between two consecutive statements, we call the analysis dense. On the other hand, if these regions include many such points, then we call it sparse. This paper presents a systematic method to build program representations that support sparse analyses. To pave the way to this framework we clarify the bibliography about well-known intermediate program representations. We show that our approach, up to parameter choice, subsumes many of these representations, such as the SSA, SSI and e-SSA forms. In particular, our algorithms are faster, simpler and more frugal than the previous techniques used to construct SSI - Static Single Information - form programs. We produce intermediate representations isomorphic to Choi et al.'s Sparse Evaluation Graphs (SEG) for the family of data-flow problems that can be partitioned per variables. However, contrary to SEGs, we can handle - sparsely - problems that are not in this family

SSI Revisited

The static single information (SSI) form, proposed by Ananian, then in a more general form by Singer, is an extension of the static single assignment (SSA) form. The latter is a well-established compiler intermediate representation that has been successfully used for numerous compiler analysis and optimizations. Several interesting results have also been shown for SSI concerning liveness analysis and representation of live-ranges of variables, which could make SSI appealing for just-in-time compilation. Unfortunately, previous literature on the SSI form is sparse and appears to be partly incorrect. Our paper corrects some of the mistakes that have been made. Our main result is a complete proof that, even for the most general definition of SSI, basic blocks, and thus program points, can be totally ordered so that live-ranges of variables correspond to intervals. This corrects the erroneous proof of Brisk and Sarrafzadeh

OpenMosix, OpenSSI and Kerrighed: A Comparative Study

This paper presents a comparative study of Kerrighed, openMosix and OpenSSI, three Single System Image (SSI) operating systems for clusters. This experimental study gives an overview of SSI features offered by these SSI and evaluates performance of such features

Revisiting Out-of-SSA Translation for Correctness, Code Quality, and Efficiency

Compared to the previous versions, the only change is correcting an awful typo that made Algorithm 1 wrong. Line 18 is not "if b = loc(pred(b))" but simply "if b = loc(b)".Static single assignment (SSA) form is an intermediate program representation in which many code optimizations can be performed with fast and easy-to-implement algorithms. However, some of these optimizations create situations where the SSA variables arising from the same original variable now have overlapping live ranges. This complicates the translation out of SSA code into standard code. There are three issues to consider: correctness, code quality (elimination of copies), and algorithm efficiency (speed and memory footprint). Briggs et al. proposed patches to correct the initial approach of Cytron et al. A cleaner and more general approach was proposed by Sreedhar et al., along with techniques to reduce the number of generated copies. We propose a new approach based on coalescing and a precise view of interferences, in which correctness and optimizations are separated. Our approach is provably correct and simpler to implement, with no patches or particular cases as in previous solutions, while reducing the number of generated copies. Also, experiments with SPEC CINT2000 show that it is 2x faster and 10x less memory-consuming than the Method~III of Sreedhar et al., which makes it suitable for just-in-time compilation

Vers un compilateur avec une phase terminal basé sur SSA: des propriétés intéressantes de la forme SSA et de ses extensions

Les contributions de cette thèse s'articulent autour de trois axes, en lien avec la forme SSA. Tout d'abord, nous nous sommes intéressés aux algorithmes d'analyse de vivacité sous la forme SSA. Nous présentons un algorithme rapide, qui s'appuie sur la structure du programme (notamment les boucles) et sur les propriétés spécifiques à la forme SSA. Ensuite nous présentons une représentation dérivée de SSA : la forme Static Single Information (SSI). D'abord, nous clarifions les différentes définitions apparues antérieurement. Puis nous montrons que le graphe d'intersection de la vivacité des variables sous la forme SSI est un graphe d'intervalles. Ceci nous permet de présenter un algorithme de vivacité plus efficace. Finalement dans un dernière partie nous proposons une approche novatrice pour la redescente SSA. Notre méthode, bien que conceptuellement plus simple, nous permet d'obtenir des résultats de qualité équivalente aux méthodes précédentes..This thesis is articulated around three topics, all of them related to the SSA form. First, we explore the optimization of liveness algorithms when applied to program in SSA form. In particular we present an efficient algorithm, based on the structure of the program (the loops) and based on properties specific to SSA form. Next we present an intermediate representation which is a variant of SSA: the Static Single Information form (SSI). We clarify the different definitions for this form which appeared in the literature, pointing out the points where they diverge. Then we prove that the interference graph (the intersection graph of the live-ranges) of variables under SSI form is an interval graph. Finally, we propose a new approach to the problem of SSA destruction. Our method, while simpler than previous approach, gives us results comparable to more complex and not always proved approaches.LYON-ENS Sciences (693872304) / SudocSudocFranceF

Parameterized Construction of Program Representations for Sparse Dataflow Analyses

Data-flow analyses usually associate information with control flow regions. Informally, if these regions are too small, like a point between two consecutive statements, we call the analysis dense. On the other hand, if these regions include many such points, then we call it sparse. This paper presents a systematic method to build program representations that support sparse analyses. To pave the way to this framework we clarify the bibliography about well-known intermediate program representations. We show that our approach, up to parameter choice, subsumes many of these representations, such as the SSA, SSI and e-SSA forms. In particular, our algorithms are faster, simpler and more frugal than the previous techniques used to construct SSI - Static Single Information - form programs. We produce intermediate representations isomorphic to Choi et al.'s Sparse Evaluation Graphs (SEG) for the family of data-flow problems that can be partitioned per variables. However, contrary to SEGs, we can handle - sparsely - problems that are not in this family.L'analyse de flot de données, associe en général l'information calculée, aux régions de flot de contrôle. Informellement cette analyse est dite dense, si ces régions sont trop petites, i.e. par exemple restreintes aux points de programme situés entre deux instructions. A l'opposé, cette analyse est dite creuse, si ces régions comprennent de nombreux points consécutifs. Cet article présente une méthode de construction systématique d'une représentation de programme qui permet de manière naturelle l'implémentation d'analyses creuses. Cette forme englobe plusieurs forme existante comme la forme SSA, la forme SSI, ou la forme e-SSA. En particulier, l'algorithme présenté est plus rapide, plus simple et moins gourmand que les méthodes existantes de construction de SSI --Static Single Information. Aussi, la représentation ainsi construite se trouve être isomorphe au graphe d'évaluation creux (Sparse Evaluation Graph --- SEG in English) de Choi et al. dans le cas particulier ou le problème d'analyse de flot de données peut être partitionné par variable. Cela dit, contrairement aux SEG, l'approche ici décrite n'est pas restreinte à cette famille de problèmes

sous la direction de

In computing environment, failures are not the exception. Computers are subject to operating system bugs, hardware failures or malware attacks. In a clustering or grid environment, management tools are needed to improv

Computing Liveness Sets for SSA-Form Programs

We revisit the problem of computing liveness sets, i.e., the set of variables live-in and live-out of basic blocks, for programs in strict SSA (static single assignment). Strict SSA is also known as SSA with dominance property because it ensures that the definition of a variable always dominates all its uses. This property can be exploited to optimize the computation of liveness sets. Our first contribution is the design of a fast data-flow algorithm, which, unlike traditional approaches, avoids the iterative calculation of a fixed point. Thanks to the properties of strict SSA form and the use of a loop-nesting forest, we show that two passes are sufficient. A first pass, similar to the initialization of iterative data-flow analysis, traverses the control-flow graph in postorder propagating liveness information backwards. A second pass then traverses the loop-nesting forest, updating liveness information within loops. Another approach is to propagate from uses to definition, one variable and one path at a time, instead of unioning sets as in standard data-flow analysis. Such a path-exploration strategy was proposed by Appel in his ''Tiger book'' and is also used in the LLVM compiler. Our second contribution is to show how to extend and optimize algorithms based on this idea to compute liveness sets one variable at a time using adequate data~structures. Finally, we evaluate and compare the efficiency of the proposed algorithms using the SPECINT 2000 benchmark suite. The standard data-flow approach is clearly outperformed, all algorithms show substantial speed-ups of a factor of 2 on average. Depending on the underlying set implementation either the path-exploration approach or the loop-forest-based approach provides superior performance. Experiments show that our loop-forest-based algorithm provides superior performances (average speed-up of 43% on the fastest alternative) when sets are represented as bitsets and for optimized programs, i.e., when there are more variables and larger live-sets and live-ranges.Nous réexaminons le problème du calcul des ensembles de vivacité, c'est-à-dire des ensembles de variables en vie en entrée et sortie des blocs de base d'un programme en forme SSA (assignation unique statique) stricte. La forme SSA stricte est également appelée SSA avec propriété de dominance parce qu'elle garantit que la définition d'une variable domine toujours toutes ses utilisations. Nous exploitons cette propriété pour optimiser le calcul de vivacité. Notre première contribution est la conception d'un algorithme rapide de type flot de données qui, à la différence des approches traditionnelles, évite les itérations de calcul de point fixe. Grâce aux propriétés de la forme SSA stricte et à l'utilisation d'une hiérarchie de boucles (''loop-nesting forest''), nous montrons que deux passes sont suffisantes. Une première passe, similaire à la phase d'initialisation de la méthode de flot de données itérative, propage les informations de vivacité en remontant un parcours en profondeur du graphe de flot de contrôle. Une deuxième passe parcourt la hiérarchie de boucles pour mettre à jour l'information dans les boucles. Une autre approche consiste à propager depuis les utilisations jusqu'à la définition, une variable et un chemin à la fois, plutôt que d'effectuer des unions d'ensembles comme dans l'analyse de flot de données standard. Une telle stratégie d'exploration des chemins a été proposée par Appel dans son ''Tiger book'' et est également utilisée dans le compilateur LLVM. Notre seconde contribution est de montrer comment étendre et optimiser un algorithme basé sur cette idée pour calculer les ensembles de vivacité, une variable à la fois, et avec des structures de données adéquates. Finalement, nous évaluons et comparons les performances des algorithmes proposés avec les ''benchmarks'' de SPECINT 2000. L'approche traditionnelle de flot de données est clairement surpassée par les autres algorithmes, avec un facteur d'amélioration de 2 en moyenne. Selon l'implantation des ensembles de vivacité, la meilleure approche est soit celle par remontée de chemin, soit celle utilisant la hiérarchie de boucles. Les expérimentations montrent que notre algorithme flot de données offre de meilleures performances (amélioration de 43% par rapport à la meilleure alternative) quant les ensembles sont représentés par des ''bitsets'' et pour les programmes optimisés, programmes avec plus de variables, et des ensembles de vivacité et des intervalles de vie plus grands